home *** CD-ROM | disk | FTP | other *** search
/ Kit PC World De Ampliacion De Windows 95 / Kit PC World de ampliacion de Windows 95.iso / internet / sweeper / samples / olecon~1 / controls / fontco~1 / fontco~2.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-30  |  22.5 KB  |  795 lines
  1. //=--------------------------------------------------------------------------=
  2. // FontColorCtl.Cpp
  3. //=--------------------------------------------------------------------------=
  4. // Copyright  1995  Microsoft Corporation.  All Rights Reserved.
  5. //
  6. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
  7. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
  8. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
  9. // PARTICULAR PURPOSE.
  10. //=--------------------------------------------------------------------------=
  11. //
  12. #include "IPServer.H"
  13.  
  14. #include "Guids.H"
  15. #include "FontColorCtl.H"
  16. #include "LocalObj.H"
  17. #include "Util.H"
  18. #include "Globals.H"
  19. #include "Resource.H"
  20.  
  21. // for ASSERT and FAIL
  22. //
  23. SZTHISFILE
  24.  
  25. //=--------------------------------------------------------------------------=
  26. // persistence helpers
  27. //
  28. #define STREAMHDR_MAGIC    0x12345678
  29.  
  30. typedef struct {
  31.  
  32.     DWORD dwMagic;
  33.     DWORD dwVersion;
  34.     DWORD cbSize;
  35.  
  36. } STREAMHDR;
  37.  
  38. WCHAR wszForeColor [] = L"ForeColor";
  39. WCHAR wszFont [] = L"Font";
  40.  
  41. static FONTDESC _fdDefault = {
  42.     sizeof(FONTDESC),
  43.     L"MS Sans Serif",
  44.     FONTSIZE(12),
  45.     FW_NORMAL,
  46.     DEFAULT_CHARSET,
  47.     FALSE,
  48.     FALSE,
  49.     FALSE
  50. };
  51.  
  52.  
  53.  
  54. //=--------------------------------------------------------------------------=
  55. // array describing all of our property pages.  these clsids are typically
  56. // in guids.h
  57. //
  58. // TODO: add any additional property page guids here ...
  59. //
  60. const GUID *rgFontColorPropPages [] = {
  61.     &CLSID_FontColorGeneralPage
  62. };
  63.  
  64. //=--------------------------------------------------------------------------=
  65. // Custum Verb information
  66. //
  67. // TODO: add any custom verbs here in an array, using the VERBINFO structure.
  68. //       then mark the controld def'n in FontColorCtl.H with
  69. //       this verb array
  70. //
  71.  
  72.  
  73. //=--------------------------------------------------------------------------=
  74. // CFontColorControl::Create
  75. //=--------------------------------------------------------------------------=
  76. // global static function that creates an instance of the control an returns
  77. // an IUnknown pointer for it.
  78. //
  79. // Parameters:
  80. //    IUnknown *        - [in] controlling unknown for aggregation
  81. //
  82. // Output:
  83. //    IUnknown *        - new object.
  84. //
  85. // Notes:
  86. //
  87. IUnknown *CFontColorControl::Create
  88. (
  89.     IUnknown *pUnkOuter
  90. )
  91. {
  92.     // make sure we return the private unknown so that we support aggegation
  93.     // correctly!
  94.     //
  95.     CFontColorControl *pNew = new CFontColorControl(pUnkOuter);
  96.     return pNew->PrivateUnknown();
  97. }
  98.  
  99. //=--------------------------------------------------------------------------=
  100. // CFontColorControl::CFontColorControl
  101. //=--------------------------------------------------------------------------=
  102. // "Being born is like being kidnapped.  And then sold into slavery."
  103. //    - andy warhol (1928 - 87)
  104. //
  105. // Parameters:
  106. //    IUnknown *        - [in]
  107. //
  108. // Notes:
  109. //
  110. #pragma warning(disable:4355)  // using 'this' in constructor
  111. CFontColorControl::CFontColorControl
  112. (
  113.     IUnknown *pUnkOuter
  114. )
  115. : COleControl(pUnkOuter, OBJECT_TYPE_CTLFONTCOLOR, (IDispatch *)this)
  116. {
  117.     m_state.ocForeColor = COLOR_WINDOWTEXT | 0x80000000;
  118.     m_pFont = NULL;
  119.  
  120. }
  121. #pragma warning(default:4355)  // using 'this' in constructor
  122.  
  123. //=--------------------------------------------------------------------------=
  124. // CFontColorControl::~CFontColorControl
  125. //=--------------------------------------------------------------------------=
  126. // "We all labour against our own cure, for death is the cure of all diseases"
  127. //    - Sir Thomas Browne (1605 - 82)
  128. //
  129. // Notes:
  130. //
  131. CFontColorControl::~CFontColorControl ()
  132. {
  133.     RELEASE_OBJECT(m_pFont);
  134. }
  135.  
  136. //=--------------------------------------------------------------------------=
  137. // CFontColorControl:RegisterClassData
  138. //=--------------------------------------------------------------------------=
  139. // register the window class information for your control here.
  140. // this information will automatically get cleaned up for you on DLL shutdown.
  141. //
  142. // Output:
  143. //    BOOL            - FALSE means fatal error.
  144. //
  145. // Notes:
  146. //
  147. BOOL CFontColorControl::RegisterClassData
  148. (
  149.     void
  150. )
  151. {
  152.     WNDCLASS wndclass;
  153.  
  154.     // TODO: register any additional information you find interesting here.
  155.     //       this method is only called once for each type of control
  156.     //
  157.     memset(&wndclass, 0, sizeof(WNDCLASS));
  158.     wndclass.style          = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS;
  159.     wndclass.lpfnWndProc    = COleControl::ControlWindowProc;
  160.     wndclass.hInstance      = g_hInstance;
  161.     wndclass.hCursor        = LoadCursor(NULL, IDC_ARROW);
  162.     wndclass.hbrBackground  = (HBRUSH)(COLOR_WINDOW + 1);
  163.     wndclass.lpszClassName  = WNDCLASSNAMEOFCONTROL(OBJECT_TYPE_CTLFONTCOLOR);
  164.  
  165.     return RegisterClass(&wndclass);
  166. }
  167.  
  168. //=--------------------------------------------------------------------------=
  169. // CFontColorControl::BeforeCreateWindow
  170. //=--------------------------------------------------------------------------=
  171. // called just before the window is created.  Great place to set up the
  172. // window title, etc, so that they're passed in to the call to CreateWindowEx.
  173. // speeds things up slightly.
  174. //
  175. // Notes:
  176. //
  177. void CFontColorControl::BeforeCreateWindow
  178. (
  179.     void
  180. )
  181. {
  182.     // TODO: users should modify m_dwWindowStyle, m_dwWindowStyleEx, m_szWindowTitle
  183.     // et al here so that the call to createwindow has as much information as
  184.     // possible.
  185.     // if you don't use this function, then you can probably just remove it.
  186. }
  187.  
  188. //=--------------------------------------------------------------------------=
  189. // CFontColorControl::InternalQueryInterface
  190. //=--------------------------------------------------------------------------=
  191. // qi for things only we support.
  192. //
  193. // Parameters:
  194. // Parameters:
  195. //    REFIID        - [in]  interface they want
  196. //    void **       - [out] where they want to put the resulting object ptr.
  197. //
  198. // Output:
  199. //    HRESULT       - S_OK, E_NOINTERFACE
  200. //
  201. // Notes:
  202. //
  203. HRESULT CFontColorControl::InternalQueryInterface
  204. (
  205.     REFIID  riid,
  206.     void  **ppvObjOut
  207. )
  208. {
  209.     IUnknown *pUnk;
  210.  
  211.     *ppvObjOut = NULL;
  212.  
  213.     // TODO: if you want to support any additional interrfaces, then you should
  214.     // indicate that here.  never forget to call COleControl's version in the
  215.     // case where you don't support the given interface.
  216.     //
  217.     if (DO_GUIDS_MATCH(riid, IID_IFontColor)) {
  218.         pUnk = (IUnknown *)(IFontColor *)this;
  219.     } else{
  220.         return COleControl::InternalQueryInterface(riid, ppvObjOut);
  221.     }
  222.  
  223.     pUnk->AddRef();
  224.     *ppvObjOut = (void *)pUnk;
  225.     return S_OK;
  226. }
  227.  
  228. //=--------------------------------------------------------------------------=
  229. // CFontColorControl::LoadTextState
  230. //=--------------------------------------------------------------------------=
  231. // load in our text state for this control.
  232. //
  233. // Parameters:
  234. //    IPropertyBag *        - [in] property bag to read from
  235. //    IErrorLog *           - [in] errorlog object to use with proeprty bag
  236. //
  237. // Output:
  238. //    HRESULT
  239. //
  240. // Notes:
  241. //    - NOTE: if you have a binary object, then you should pass an unknown
  242. //      pointer to the property bag, and it will QI it for IPersistStream, and
  243. //      get said object to do a Load()
  244. //
  245. STDMETHODIMP CFontColorControl::LoadTextState
  246. (
  247.     IPropertyBag *pPropertyBag,
  248.     IErrorLog    *pErrorLog
  249. )
  250. {
  251.     HRESULT hr;
  252.     VARIANT v;
  253.  
  254.     v.vt = VT_I4;
  255.     v.lVal = 0;
  256.  
  257.     // load in our forecolor and font properties.
  258.     //
  259.     hr = pPropertyBag->Read(wszForeColor, &v, pErrorLog);
  260.     if (SUCCEEDED(hr)) m_state.ocForeColor = (OLE_COLOR)v.lVal;
  261.  
  262.     v.vt = VT_UNKNOWN;
  263.     v.punkVal = NULL;
  264.     hr = pPropertyBag->Read(wszFont, &v, pErrorLog);
  265.     if (SUCCEEDED(hr)) {
  266.         ASSERT(!m_pFont, "how come i already have a font??");
  267.         hr = v.punkVal->QueryInterface(IID_IFont, (void **)&m_pFont);
  268.         v.punkVal->Release();
  269.         RETURN_ON_FAILURE(hr);
  270.     }
  271.  
  272.     return S_OK;
  273. }
  274.  
  275. //=--------------------------------------------------------------------------=
  276. // CFontColorControl::LoadBinaryState
  277. //=--------------------------------------------------------------------------=
  278. // loads in our binary state using streams.
  279. //
  280. // Parameters:
  281. //    IStream *            - [in] stream to write to.
  282. //
  283. // Output:
  284. //    HRESULT
  285. //
  286. // Notes:
  287. //
  288. STDMETHODIMP CFontColorControl::LoadBinaryState
  289. (
  290.     IStream *pStream
  291. )
  292. {
  293.     IPersistStream *pps;
  294.     STREAMHDR sh;
  295.     HRESULT   hr;
  296.  
  297.     // first read in the streamhdr, and make sure we like what we're getting
  298.     //
  299.     hr = pStream->Read(&sh, sizeof(sh), NULL);
  300.     RETURN_ON_FAILURE(hr);
  301.  
  302.     // sanity check
  303.     //
  304.     if (sh.dwMagic != STREAMHDR_MAGIC || sh.cbSize != sizeof(m_state))
  305.         return E_UNEXPECTED;
  306.  
  307.     // read in the control state information
  308.     //
  309.     hr = pStream->Read(&(m_state), sizeof(m_state), NULL);
  310.     RETURN_ON_FAILURE(hr);
  311.  
  312.  
  313.     // now read in the font!
  314.     //
  315.     OleCreateFontIndirect(&_fdDefault, IID_IFont, (void **)&m_pFont);
  316.     RETURN_ON_NULLALLOC(m_pFont);
  317.  
  318.     // qi it for ipersiststream and load it in.
  319.     //
  320.     hr = m_pFont->QueryInterface(IID_IPersistStream, (void **)&pps);
  321.     RETURN_ON_FAILURE(hr);
  322.  
  323.     hr = pps->Load(pStream);
  324.     pps->Release();
  325.  
  326.     return hr;
  327. }
  328.  
  329. //=--------------------------------------------------------------------------=
  330. // CFontColorControl::SaveTextState
  331. //=--------------------------------------------------------------------------=
  332. // saves out the text state for this control using a property bag.
  333. //
  334. // Parameters:
  335. //    IPropertyBag *        - [in] the property bag with which to work.
  336. //    BOOL                  - [in] if TRUE, then write out ALL properties, even
  337. //                            if they're their the default value ...
  338. //
  339. // Output:
  340. //    HRESULT
  341. //
  342. // Notes:
  343. //
  344. STDMETHODIMP CFontColorControl::SaveTextState
  345. (
  346.     IPropertyBag *pPropertyBag,
  347.     BOOL          fWriteDefaults
  348. )
  349. {
  350.     VARIANT v;
  351.     HRESULT hr;
  352.  
  353.     // save out forecolor and font.
  354.     //
  355.     v.vt = VT_I4;
  356.     v.lVal = (long) m_state.ocForeColor;
  357.  
  358.     if (m_state.ocForeColor != (COLOR_WINDOWTEXT | 0x80000000) || fWriteDefaults) {
  359.         hr = pPropertyBag->Write(wszForeColor, &v);
  360.         RETURN_ON_FAILURE(hr);
  361.     }
  362.  
  363.     // CONSIDER: have some sort of way of knowning if we've got our own
  364.     // font, or just the ambient font ...
  365.     //
  366.     if (m_pFont || fWriteDefaults) {
  367.         if (!m_pFont) {
  368.             IFontDisp *pfd;
  369.             hr = get_Font(&pfd);
  370.             RETURN_ON_FAILURE(hr);
  371.             pfd->Release();
  372.         }
  373.         v.vt = VT_UNKNOWN;
  374.         v.punkVal = m_pFont;
  375.         hr = pPropertyBag->Write(wszFont, &v);
  376.         RETURN_ON_FAILURE(hr);
  377.     }
  378.  
  379.     return S_OK;
  380. }
  381.  
  382. //=--------------------------------------------------------------------------=
  383. // CFontColorControl::SaveBinaryState
  384. //=--------------------------------------------------------------------------=
  385. // save out the binary state for this control, using the given IStream object.
  386. //
  387. // Parameters:
  388. //    IStream  *             - [in] save to which you should save.
  389. //
  390. // Output:
  391. //    HRESULT
  392. //
  393. // Notes:
  394. //    - it is important that you seek to the end of where you saved your
  395. //      properties when you're done with the IStream.
  396. //
  397. STDMETHODIMP CFontColorControl::SaveBinaryState
  398. (
  399.     IStream *pStream
  400. )
  401. {
  402.     IPersistStream *pps;
  403.     IFontDisp *pfd;
  404.     STREAMHDR sh = { STREAMHDR_MAGIC, MAKELONG(1, 0), sizeof(m_state) };
  405.     HRESULT hr;
  406.  
  407.     // write out the stream hdr.
  408.     //
  409.     hr = pStream->Write(&sh, sizeof(sh), NULL);
  410.     RETURN_ON_FAILURE(hr);
  411.  
  412.     // write out he control state information
  413.     //
  414.     hr = pStream->Write(&m_state, sizeof(m_state), NULL);
  415.     RETURN_ON_FAILURE(hr);
  416.  
  417.     // now just save out the font.
  418.     //
  419.     hr = get_Font(&pfd);
  420.     RETURN_ON_FAILURE(hr);
  421.     hr = pfd->QueryInterface(IID_IPersistStream, (void **)&pps);
  422.     pfd->Release();
  423.     RETURN_ON_FAILURE(hr);
  424.  
  425.     hr = pps->Save(pStream, TRUE);
  426.     pps->Release();
  427.  
  428.     return hr;
  429. }
  430.  
  431. //=--------------------------------------------------------------------------=
  432. // CFontColorControl::OnDraw
  433. //=--------------------------------------------------------------------------=
  434. // "I don't very much enjoy looking at paintings in general.  i know too
  435. //  much about them.  i take them apart."
  436. //    - georgia o'keeffe (1887-1986)
  437. //
  438. // Parameters:
  439. //    HDC                - [in]  HDC to draw to
  440. //    LPCRECTL           - [in]  rect we're drawing to
  441. //    LPCRECTL           - [in]  window extent and origin for meta-files
  442. //    HDC                - [in]  HIC for target device
  443. //
  444. // Output:
  445. //    HRESULT
  446. //
  447. // Notes:
  448. //
  449. HRESULT CFontColorControl::OnDraw
  450. (
  451.     HDC      hdcDraw,
  452.     LPCRECTL prcBounds,
  453.     LPCRECTL prcWBounds,
  454.     HDC      hicTargetDevice
  455. )
  456. {
  457.     COLORREF rgb, rgbOld;
  458.     HRESULT hr;
  459.     IFontDisp *pFontDisp;
  460.     IFont *pFont;
  461.     HFONT hfont, hfontOld;
  462.  
  463.     // get our current font so we can get the HFONT for it!
  464.     //
  465.     hr = get_Font(&pFontDisp);
  466.     RETURN_ON_FAILURE(hr);
  467.  
  468.     hr = pFontDisp->QueryInterface(IID_IFont, (void **)&pFont);
  469.     pFontDisp->Release();
  470.     RETURN_ON_FAILURE(hr);
  471.  
  472.     hr = pFont->get_hFont(&hfont);
  473.     CLEANUP_ON_FAILURE(hr);
  474.  
  475.     // select the new font into the DC
  476.     //
  477.     hfontOld = SelectObject(hdcDraw, hfont);
  478.  
  479.     // get the color.
  480.     //
  481.     OleTranslateColor(m_state.ocForeColor, NULL, &rgb);
  482.     rgbOld = SetTextColor(hdcDraw, rgb);
  483.  
  484.     DrawText(hdcDraw, "Happy Happy Joy Joy", -1, (LPRECT)prcBounds, DT_CENTER|DT_VCENTER);
  485.  
  486.     SelectObject(hdcDraw, hfontOld);
  487.     SetTextColor(hdcDraw, rgbOld);
  488.     hr = S_OK;
  489.  
  490.   CleanUp:
  491.     pFont->Release();
  492.  
  493.     return hr;
  494. }
  495.  
  496. //=--------------------------------------------------------------------------=
  497. // CFontColorControl::WindowProc
  498. //=--------------------------------------------------------------------------=
  499. // window procedure for this control.  nothing terribly exciting.
  500. //
  501. // Parameters:
  502. //     see win32sdk on window procs.
  503. //
  504. // Notes:
  505. //
  506. LRESULT CFontColorControl::WindowProc
  507. (
  508.     HWND   hwnd,
  509.     UINT   msg,
  510.     WPARAM wParam,
  511.     LPARAM lParam
  512. )
  513. {
  514.     // TODO: handle any messages here, like in a normal window
  515.     // proc.  note that for special keys, you'll want to override and
  516.     // implement OnSpecialKey.
  517.     //
  518.     return DefWindowProc(hwnd, msg, wParam, lParam);
  519. }
  520.  
  521. //=--------------------------------------------------------------------------=
  522. // CFontColorControl::Invoke    [IDispatch]
  523. //=--------------------------------------------------------------------------=
  524. // we have to override this method to look for properties of type Font,
  525. // Picture, or OLE_COLOR.  turns out there is a bug in Ole Automation which
  526. // will cause TypeInfo::Invoke to blow up/fail when working with these types
  527. // since htey are from a nested type library.  no es bueno.
  528. //
  529. // Parameters:
  530. //    DISPID            - [in]  identifies the member we're working with.
  531. //    REFIID            - [in]  must be IID_NULL.
  532. //    LCID              - [in]  language we're working under
  533. //    USHORT            - [in]  flags, propput, get, method, etc ...
  534. //    DISPPARAMS *      - [in]  array of arguments.
  535. //    VARIANT *         - [out] where to put result, or NULL if they don't care.
  536. //    EXCEPINFO *       - [out] filled in in case of exception
  537. //    UINT *            - [out] where the first argument with an error is.
  538. //
  539. // Output:
  540. //    HRESULT           - tonnes of them.
  541. //
  542. // Notes:
  543. //    
  544. STDMETHODIMP CFontColorControl::Invoke
  545. (
  546.     DISPID      dispid,
  547.     REFIID      riid,
  548.     LCID        lcid,
  549.     WORD        wFlags,
  550.     DISPPARAMS *pdispparams,
  551.     VARIANT    *pvarResult,
  552.     EXCEPINFO  *pexcepinfo,
  553.     UINT       *puArgErr
  554. )
  555. {
  556.     HRESULT hr;
  557.  
  558.     // only have to handle it for these properties, since they're the only
  559.     // ones with STDOLE32 types ...
  560.     //
  561.     switch (dispid) {
  562.         case DISPID_FONT:
  563.         case DISPID_FORECOLOR:
  564.             break;
  565.  
  566.         // just use the regular invoke we've got ...
  567.         //
  568.         default:
  569.             return CAutomationObject::Invoke(dispid, riid, lcid, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
  570.     }
  571.  
  572.     // mask out methods, since we only are having problems with propgets and
  573.     // propputs
  574.     //
  575.     wFlags &= (DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF);
  576.  
  577.     // now, depending on what they're asking for, do something different.
  578.     //
  579.     switch (wFlags) {
  580.         case DISPATCH_PROPERTYGET:
  581.             ASSERT(pvarResult, "Duh!  can't give a result back if i don't have a place to put it!");
  582.             VariantClear(pvarResult);
  583.             // make sure they didn't send us any arguments.
  584.             //
  585.             if (pdispparams && pdispparams->cArgs != 0) {
  586.                 FAIL("Gaaak! somebody sent some arguments!!!");
  587.                 return DISP_E_BADPARAMCOUNT;
  588.             }
  589.  
  590.             // now just call the user routine
  591.             //
  592.             switch (dispid) {
  593.                 case DISPID_FONT:
  594.                     {
  595.                     IFontDisp *pFontDisp;
  596.                     pvarResult->vt = VT_DISPATCH;
  597.                     pvarResult->vt = NULL;
  598.                     hr = get_Font(&pFontDisp);
  599.                     RETURN_ON_FAILURE(hr);
  600.                     hr = pFontDisp->QueryInterface(IID_IDispatch, (void **)&(pvarResult->pdispVal));
  601.                     pFontDisp->Release();
  602.                     return hr;
  603.                     }
  604.                     break;
  605.  
  606.                 case DISPID_FORECOLOR:
  607.                     pvarResult->vt = VT_I4;
  608.                     return get_ForeColor((OLE_COLOR *)&(pvarResult->lVal));
  609.             }
  610.             break;
  611.  
  612.         case DISPATCH_PROPERTYPUT:
  613.             ASSERT(pdispparams && pdispparams->cArgs == 1, "D'oh! can't set a property without a value!");
  614.  
  615.             switch (dispid) {
  616.                 case DISPID_FORECOLOR:
  617.                     return put_ForeColor((OLE_COLOR)pdispparams->rgvarg[0].lVal);
  618.                 case DISPID_FONT:
  619.                     {
  620.                     IFontDisp *pfd;
  621.                     hr = get_Font(&pfd);
  622.                     RETURN_ON_FAILURE(hr);
  623.                     hr = pfd->Invoke(DISPID_VALUE, riid, lcid, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
  624.                     pfd->Release();
  625.                     return hr;
  626.                     }
  627.                     break;
  628.                 default:
  629.                     FAIL("Nobody should ever trip this!!!");
  630.             }
  631.  
  632.         case DISPATCH_PROPERTYPUTREF:
  633.             ASSERT(pdispparams && pdispparams->cArgs == 1, "Can't set a property without a value! Maggots!");
  634.             switch (dispid) {
  635.                 case DISPID_FONT:
  636.                     {
  637.                     IFontDisp *pFontDisp;
  638.                     hr = pdispparams->rgvarg[0].punkVal->QueryInterface(IID_IFontDisp, (void **)&pFontDisp);
  639.                     RETURN_ON_FAILURE(hr);
  640.                     hr = put_Font(pFontDisp);
  641.                     pFontDisp->Release();
  642.                     return hr;
  643.                     }
  644.                     break;
  645.                 default:
  646.                     FAIL("This should never be called!");
  647.             }
  648.  
  649.     }
  650.  
  651.     FAIL("D'oh!  i shouldn't see DISPATCH_METHOD when i'm only working with properites!");
  652.     return DISP_E_MEMBERNOTFOUND;    
  653. }
  654.  
  655.  
  656.  
  657. //=--------------------------------------------------------------------------=
  658. // CFontColorControl::AboutBox    [IFontColor]
  659. //=--------------------------------------------------------------------------=
  660. // prints up an about box.  fweeeee.
  661. //
  662. // Notes:
  663. //
  664. void CFontColorControl::AboutBox
  665. (
  666.     void
  667. )
  668. {
  669.     // TODO: Ideally, one would use DialogBox, and some sort of Dialog Box here if
  670.     // they wanted a slightly more interesting About Box ...  you should
  671.     // still call ModalDialog first, however.
  672.     //
  673.     ModalDialog(TRUE);
  674.     MessageBox(NULL, "This is My Control", "About FontColor", MB_OK | MB_TASKMODAL);
  675.     ModalDialog(FALSE);
  676. }
  677.  
  678. //=--------------------------------------------------------------------------=
  679. // CFontColorControl::get_Font    [IFontColor]
  680. //=--------------------------------------------------------------------------=
  681. // returns the current font.
  682. //
  683. // Parameters:
  684. //    IFontDisp **        -[out] figure it out.
  685. //
  686. // Output:
  687. //    HRESULT
  688. //
  689. // Notes:
  690. //
  691. STDMETHODIMP CFontColorControl::get_Font
  692. (
  693.     IFontDisp **ppFont
  694. )
  695. {
  696.     CHECK_POINTER(ppFont);
  697.  
  698.     if (!m_pFont)
  699.         GetAmbientFont(&m_pFont);
  700.  
  701.     if (m_pFont)
  702.         return m_pFont->QueryInterface(IID_IFontDisp, (void **)ppFont);
  703.  
  704.     *ppFont = NULL;
  705.     return E_UNEXPECTED;
  706. }
  707.  
  708.  
  709. //=--------------------------------------------------------------------------=
  710. // CFontColorControl::put_Font    [IFontColor]
  711. //=--------------------------------------------------------------------------=
  712. // sets the current font.
  713. //
  714. // Parameters:
  715. //    IFontDisp *pFont    - [in] duh.
  716. //
  717. // Output:
  718. //    HRESULT
  719. //
  720. // Notes:
  721. //
  722. STDMETHODIMP CFontColorControl::put_Font
  723. (
  724.     IFontDisp *pFont
  725. )
  726. {
  727.     HRESULT hr;
  728.  
  729.     RELEASE_OBJECT(m_pFont);
  730.  
  731.     // if we have a new font, get it, and do some cleaning up!
  732.     //
  733.     if (pFont) {
  734.         hr = pFont->QueryInterface(IID_IFont, (void **)&m_pFont);
  735.         RETURN_ON_FAILURE(hr);
  736.     }
  737.  
  738.     InvalidateControl(NULL);
  739.     PropertyChanged(DISPID_FONT);
  740.     m_fDirty = TRUE;
  741.     return S_OK;
  742. }
  743.  
  744. //=--------------------------------------------------------------------------=
  745. // CFontColorControl::get_ForeColor    [IFontColor]
  746. //=--------------------------------------------------------------------------=
  747. // returns current forecolor.
  748. //
  749. // Parameters:
  750. //    OLE_COLOR *    - [out].  duh.
  751. //
  752. // Output:
  753. //    HRESULT
  754. //
  755. // Notes:
  756. //
  757. STDMETHODIMP CFontColorControl::get_ForeColor
  758. (
  759.     OLE_COLOR *pocForeColor
  760. )
  761. {
  762.     CHECK_POINTER(pocForeColor);
  763.  
  764.     *pocForeColor = m_state.ocForeColor;
  765.     return S_OK;
  766. }
  767.  
  768.  
  769. //=--------------------------------------------------------------------------=
  770. // CFontColorControl::put_ForeColor    [IFontColor]
  771. //=--------------------------------------------------------------------------=
  772. // sets current foreground color.
  773. //
  774. // Parameters:
  775. //    OLE_COLOR        - [in]
  776. //
  777. // Output:
  778. //    HRESULT
  779. //
  780. // Notes:
  781. //
  782. STDMETHODIMP CFontColorControl::put_ForeColor
  783. (
  784.     OLE_COLOR ocForeColor
  785. )
  786. {
  787.     m_state.ocForeColor = ocForeColor;
  788.     InvalidateControl(NULL);
  789.     m_fDirty = TRUE;
  790.     return S_OK;
  791. }
  792.  
  793.  
  794.  
  795.